Lien Github - pour télécharger les documents associés

1. Base

1. Opérateurs et fonctions Base R


Pour quoi utiliser langage R

R est un environnement puissant et extensible. Il dispose d’un large éventail de statistiques et de capacités d’analyse et de visualisation de données

  • langage basé sur la notion de vecteur, ce qui simplifie les calculs mathématiques
  • Manipulation, calcul et stockage des données
  • Tres puissant avec les graphiques, cartographie, analisis
  • Open source avec une grande communauté
  • C’est gratuit

Projets R

Le plus efficace maniere de travailler avec R est en utilisant les dossiers de projets. Ca permet:

  • définit automatiquement le répertoire de travail sur le dossier racine du projet
  • chemins d’accès faciles aux fichiers (chemins relatifs)
  • facilitez l’organization et le partage de projets et code.

Exercise

  1. Ouvrez RStudio et creer un nouveau project/dossier qui s’appelle “Formation_BF”.
  2. Dans ce dossier creer un autre dossier qui s’appelle ‘donnees’. Ajouter les données d’evaluation HSM et du MSNA 2020 dans ce dossier.
  3. Dans le projet ouvrez un nouveau script R (ctrl + shift + N)

Types/Modes de données


L’opérateur d’assignation

Pour conserver le résultat d’une opération, on peut le stocker dans un objet à l’aide de l’opérateur d’assignation <-. Cette “flèche” stocke ce qu’il y a à sa droite dans un objet dont le nom est indiqué à sa gauche.

x <- 8
x
## [1] 8
y <- x + 6
y
## [1] 14
capitale <- "Ouagadougou"
capitale
## [1] "Ouagadougou"

Autres opérateurs importants

operateurs mathematiques

operateurs relationnel

Exercise

  1. Utilisez l’opérateur d’assignation pour assigner valeurs numeriques a une variable x et une variable y.
  2. Essayez faire quelques testes avec les operateurs relationnel

Vecteurs

  • Un vecteur est un ensemble d’éléments, tous du même type.
  • Vecteurs sont les blocs de construction de langage R
  • Une collection de vecteurs peut être défini avec the fonction “c”

Examples comment on peut construir un vecteur manuellement:

regions <- c("Centre", "Est" , "Nord", "Sahel")
nombres <- 1:8
regions
## [1] "Centre" "Est"    "Nord"   "Sahel"

On peut acceder une variable dans un vecteur avec “[ ]”:

regions[2]
## [1] "Est"

operateurs logiques


Structures de données - Data Frame

Un data frame est une liste de classe “data.frame” dont tous les éléments sont de la même longueur (ou comptent le même nombre de lignes si les éléments sont des matrices).

Il est généralement représenté sous la forme d’un tableau à deux dimensions. Chaque élément de la liste sous-jacente correspond à une colonne.

On crée un data frame avec la fonction data.frame ou, pour convertir un autre type d’objet en data frame, avec as.data.frame.

  • columns: variables accédé avec le signe $ dans le format “tableau$variable”
  • Aussi les variables peut etre accédé avec la notation tableau[[1]]
  • rows: lignes / observations

Importer csv

  • On utilise le fonction ‘read.csv’ pour importer un csv. Dans un projet R il faut que mettre le chemin relatif des données.
  • Normalment les donnees se convertit en format data frame avec read.csv
  • C’est advisable que les noms de colonnes sont en format ‘kobo name’ avant de importer
  • Aussi, quand on importe donnee dans format csv, c’est tres important definer les veleurs NA potentielles avec l’argument “na.strings”. Ca reduit des problemes a l’avenir.
hsm_df <- read.csv("donnees/tableaux/REG1903b_3_Frontiers_HSM_Burkina_Faso_2021-03-16.csv", 
                   na.strings = c("NA", "", "N/A", "N.A.", "NnA"),
                   encoding = "UTF-8")

Pour acceder las variables on utilise $ ou [[ ]]

hsm_df$ic_genre

est égal à

hsm_df[[13]]

Exercise

  1. Importez le tableau de données d’evaluation HSM en utilisant la fonction read.csv() et appelez-le un nom pertinant avec l’opérateur d’assignation.
  2. Inspectez les variables avec l’operateur $

Foncions de Base R: Inspections de données

  • str(): detalles compact du contenu des données

  • class(): le type de données de la variable.

  • head(): les entrées de début de la variable

  • tail(): les entrées du fin de la variable

  • dim(): dimensions des tableaux (n colonnes et n observations)

  • nrow(): nombre de observations des tableaux

  • ncol(): nombre de colonnes des tableaux

  • length(): retourne le nombre d’éléments dans un vecteur ou un facteur

Foncions de Base R: Convertir entre differents types de données

  • as.numeric(): convertit en un format numérique
  • as.character(): convertit en un format de caractère

Exercise

  1. Inspectez les donnees HSM avec les fonctiones au dessus.
  2. Utilisez le $ pour faire ces operations avec une seule variable.

Foncions de Base R: fonction ‘table’

La fonction table nous permet croisser variables facilment dans le console. C’est tres utile pour des analisis rapides et pour identifiquer valeurs NA.

table(hsm_df$ic_genre)
## 
## Femme Homme 
##   624  1343

Et pour comparer deux variables:

table(hsm_df$ic_genre, hsm_df$admin1)
##        
##         Centre-Nord Est Nord Sahel
##   Femme         131 262  164    67
##   Homme         414 368  284   277

On peut aussi assigner un tabl

Exercise

  1. Utilisez la fonction table pour comparer multi variables avec les donnees HSM.

Fonctions de Base R - statistiques descriptives

Les rubriques d’aide des diverses fonctions de R contiennent une foule d’informations ainsi que des exemples d’utilisation. Leur consultation est tout à fait essentielle. Pour consulter

  • min(): retourne la variable moins grand (variables de caractères aussi)

  • max(): retourne la variable plus grand

  • mean(): retourne la moyenne de une ensemble de valeurs

  • median(): retourne la medianne de une ensemble de valeurs

  • range(): vecteur contenant le minimum et le maximum d’un vecteur

  • quantile(): quantiles empiriques

  • summary(): statistiques descriptives d’un échantillon

summary(hsm_df$ic_age)
##    Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
##   18.00   28.00   35.00   35.45   42.00   81.00

Exercise

  1. Investiger les donnees dans les manieres au dessous.

Fonctions de Base R - is.na() et !is.na() - permet identifier si une variable est NA ou non.

table(is.na(hsm_df$pdi_temps_arrivee))
## 
## FALSE  TRUE 
##  1503   464

Exercise

  1. Utilisez la fonction ‘is.na()’ ensemble avec la fonction table.

Fonctions de Base R: Subset

Dans R, la commande «subset» est utilisée pour filtrer les données dans une trame de données en fonction des critères que vous avez définis.

Lorsque nous sous-ensembles de données, il est recommandé de les affecter à un nouveau objet / cadre de données afin que les données ne soient pas perdues.

La fonction de subset prend la forme suivante:

subset_df <- subset(hsm_df, criteria)

Où les critères se réfèrent à une variable numérique ou catégorique. Les critères de variables catégorielles apparaissent toujours entre guillemets.

Exemples:

Variables numériques

subset_df <- subset(hsm_df, ic_age>=30) 

Variables catégorielles

subset_df <- subset(hsm_df, admin1=="Est")

Exercise

  1. Effectuez 3 subsets de votre hsm données, en attribuant chacun à une nouvelle trame de données.

Au moins un de ces sous-ensembles doit être d’une variable catégorielle (c’est-à-dire tous «hommes») et au moins un doit être d’une variable numérique (c’est-à-dire plus ou moins d’un nombre)


Comparison entre variables

On peut utiliser cette format en dessous de pour faire une comparaison entre deux variables, isoler une réponse d’une.

mean(hsm_df$ic_age[hsm_df$admin1 == "Est"])
## [1] 31.89841

Fonctions de Base R - recherche d’éléments

%in%

L’opérateur %in% c’est tres utile. Il teste si une valeur fait partie des elements dun vecteur. Nous permet ecrire moins code. C’est particulairment utile pour faire le recodage d’un analisis avec questions multi en kobo.

regions %in% c("Est", "Nord")
## [1] FALSE  TRUE  TRUE FALSE

est égal à

regions == "Est" | regions == "Nord"
## [1] FALSE  TRUE  TRUE FALSE

Fonctions de Base R - Autres Fonctions Utiles

  • round(): arrondit un nombre décimal Par example ce code va arrondir le nombre a juste un décimal:
round(102.47333, 1) 
## [1] 102.5
  • duplicated(): identifier les valeurs en double

  • unique(): extraction des éléments différents d’un vecteur

  • which(): positions des valeurs TRUE dans un vecteur booléen

grep

Grep nous permet chercher dans donnees particulaires pour modèles spécifiques.

Par example ici on peut chercher pour “autre” apres de un “.” dans les noms de colonnes des donnees HSM.

# numeros des colonnes
noms_autres <- grep("[.]autre", names(hsm_df))
noms_autres

[1] 84 101 123 139 153 173 194 210 227 250 282 297 354

# noms des colonnes
noms_autre <- names(hsm_df)[grep(".[.]autre", names(hsm_df))]
noms_autre

[1] “pas_nourriture_raison.autre” “strat_survie.autre”
[3] “revenu_source.autre” “activites_actuelles_non.autre”
[5] “activite_agricole_perturbe.autre” “services_sante_niger.autre”
[7] “services_sante_burkina.autre” “services_sante_mali.autre”
[9] “nutri_programme.autre” “population_inquietudes.autre”
[11] “besoin_bna.autre” “bna_pas_dispo.autre”
[13] “aap.autre”

gsub

gsub nous permet remplacer carateres facilment dans les donnees. Il utilise le syntaxe de

Pour nous permetir sorter et ordonner le tableau on peut utiliser le fonction “as.datatable” ensemble avec “formattable”.

names(data)<-gsub("\\/",".",names(data)) 

gsub et grep utilise les modeles qui viennent des expresiones regulaires.

Expresiones Regulaires (Regex) sommaire
Site pour tester les Regex

Fonctions Apply

La famille des fonctions apply nous permet apliquer n’importe quelle fonction a un structure de données.

apply(X, MARGIN, FUN, …)

MARGIN est une variable définissant comment la fonction est appliquée: lorsque MARGIN = 1, elle s’applique sur les lignes, alors qu’avec MARGIN = 2, cela fonctionne sur les colonnes. Notez que lorsque vous utilisez la construction MARGIN = c (1,2), elle s’applique à la fois aux lignes et aux colonnes.

FUN pourrait etre toute fonction definee.

2. dplyr

ifelse

Fonction qui reçoit comme arguments une condition et le resultat ou si c’est vrai et faux. Quand c’est utilisee pour recoder, c’est normalment avisable creer un nouvelle variable.

Quand il ya plusieurs conditions c’est avisable utiliser la fonction “case_when” de dplyr (que on va couvrir plus tard)

ifelse(condition, resultat_si_vrai, resultat_si_faux)

ifelse peut etre utilisee pour remplir une nouvelle variable cree d’une autre par example:

hsm_df$ic_agees <- ifelse(hsm_df$ic_age >= 60, "oui", "non")

On peut utiliser ifelse pour la recodage des données avec %in% aussi:

hsm_df$pdi_pourcent_recode <- ifelse(hsm_df$pdi_pourcent %in% c("Moins de la moitié", 
                                  "La moitié"),
                                  "moitie_ou_moins", 
                                  hsm_df$pdi_pourcent)

#####Exercise

  1. Creez une nouvelle variable recodée dans hsm_df, en utilisant une declaration ifelse.

Packages

Maintenant on va installer le package dyplr pour utiliser ses fonctions. Les packages sont installees avec la fonction install.packages("") :

install.packages("dplyr")

Chergez le package:

library(dplyr)

dplyr et ses fonctions

dplyr est une grammaire (package) de manipulation de données, fournissant un ensemble cohérent de verbes (fonctions) qui vous aident à résoudre les défis de manipulation de données les plus courants. Il fait partie du groupe de bibliothèques Tidyverse pour R.

Fonctions cles de dplyr:

case_when

La fonction case_when c’est similaire a ifelse mais plus flexible ou c’est plus facile incorporer plusieurs conditions. Le resultat de defaut c’est definee avec TRUE:

case_when(condition1 ~ resultat1, condition2 ~ resultat2, TRUE ~ resultat de defaut)

Un example d’un recodage avec case_when:

hsm_df$nour_source_recode <- case_when(hsm_df$nourriture_source == "Achetée avec de l'argent" ~ "argent",
                                       hsm_df$nourriture_source == "Aide humanitaire/aide alimentaire gouvernementale" ~ "aide",
                                       hsm_df$nourriture_source == "Propre production (cultivée)" ~ "propre_prod",
                                       TRUE ~ "autre"
                                       )

#####Exercise

  1. Utilisez “case_when”" pour faire une reclassification de une colonne des données HSM

Filter

filter sélectionne des lignes d’une table selon une condition. On lui passe en paramètre un test, et seules les lignes pour lesquelles ce test renvoie TRUE (vrai) sont conservées.

on peut creer un nouveau dataframe utilisant ce filter:

hsm_df_est <- hsm_df %>% 
  filter(admin1 == "Est")

Select

permet de sélectionner des colonnes d’un tableau de données.

select(hsm_df, admin1, admin2)

le syntaxe colonne1:colonne2 permet de selectionner toutes les colonnes situees entre colonne1 et colonne2 incluses

select(hsm_df, admin1:group_pop)

aussi on peut utiliser fonctions pour selectionner colonnes qui respecter certaines regles colonnes qui commencent avec

select(hsm_df, starts_with("pdi_"))
# colonnes qui contiennent
select(hsm_df, contains("source"))

Rename

Une variant de select est rename. Ca permet de renommer de colonnes et memetemps passer une selection.

select(hsm_df, region = admin1)
Exercise
  1. Renommez une colonne avec “rename”

Arrange

arrange reordonne les lignes dun tableau selon une ou plusieurs colonnes

arrange(hsm_df, admin1)

ici premier admin1 et suivant admin2 et admin3

arrange(hsm_df, admin1, admin2, admin3)

et si on veut trier une colonne par ordre decroissant on utilise la fonction desc()

arrange(hsm_df, desc(admin1))

Mutate

  • ‘mutate’ permet de creer de nouvelles colonnes dans le tableau de donnees a partir de variables existantes
  • mutate est efvidemment compatible avec les fonctions de recodage (ie. case_when) par example:
# avec case_when
hsm_df <- mutate(hsm_df, 
                 ic_h_jeune = case_when(ic_genre == "Homme" & ic_age < 30 ~ "oui", 
                                        TRUE ~ "non"))

Le Pipe

  • Quand on manipule un tableau de données, il est très fréquent d’enchaîner plusieurs opérations.
  • ici il faut que preserver lordre des operations dans un maniere lisible aussi.
  • Pipes vienent du package “magrittr” mais sont incluees avec dplyr

une maniere de faire plusiers operations est creer un objet temporaire (ici ‘est’):

hsm_df_est <- filter(hsm_df, admin1 == 'Est')
hsm_df_est <- select(hsm_df_est, admin1:info_localite)
arrange(hsm_df_est, admin2)

la maniere mieux que on va utiliser cest l’operateur pipe %>% . On peut mettre avec le hotkey ctrl + shift + M - Ca passe le code de avant comme un argument de cette nouvelle ligne. Est tres lisable et preserver l’ordre du code.

hsm_df_est <- hsm_df %>% 
                    filter(admin1 == 'Est') %>% 
                    select(admin1:info_localite) %>% 
                    arrange(admin2)
Exercise
  1. Utilisez pipes pour faire 3 operations sur les donnees HSM et assigner a un nouveau dataframe.

Operations groupées - aggregation

Group By

group by permet de définir des groupes de lignes à partir des valeurs d’une ou plusieurs colonnes.

hsm_df %>% group_by(admin1) %>% slice(1)
  • les opérations appliquées lors du calcul des valeurs des nouvelles colonnes sont appliquées groupe de lignes par groupe de lignes.

Ensemble avec Summarize

  • normalment “group by” est utilisee ensemble avec “summarize” pour creer un tableau de donnees avec seulement une ligne par groupe le na.rm indique que la calcalution va eviter les donnees NA dans la calculation
hsm_df %>% 
  group_by(admin1) %>% 
  summarise(moy_age_oic = mean(ic_age, na.rm=TRUE))
## `summarise()` ungrouping output (override with `.groups` argument)
## # A tibble: 4 x 2
##   admin1      moy_age_oic
##   <chr>             <dbl>
## 1 Centre-Nord        36.7
## 2 Est                31.9
## 3 Nord               36.1
## 4 Sahel              39.1

Exercise

  1. Ulisant les donnees de HSM, creez deux nouvelles variables à la fois avec group by et summarize

Joins avec dplyr

Pour joigner deux tableaux ensemble, il y a plusieurs options. Une maniere est avec dplyr et sa suite

si la meme nom de colonne existe dans les deux cotes, le syntaxe est: inner_join(x, y, by = “nom_colonne”)

si la meme nom de colonne n’existe pas, le syntaxe est: inner_join(x, y, by = c(“nom_colonne_x” = “non_colonne_y”))

Ici on va voire les options de dplyr:

3. R Markdown

3. Rapports avec R Markdown


R Markdown

R Markdown est un format permettant d’écrire des rapports dynamiques reproductibles avec R. Utilisez-le pour intégrer du code R et des résultats dans des diaporamas, des fichiers PDF, des documents html et documents Word.

Documents de R Markdown ont l’extension “rmd”. Pour combiner a un document mettez la commande “Knit” dans R Studio.

Installez et chargez les packages de cette part de l’exercise.

library(dplyr)

On define le document au debut avec ce syntaxe:

---
title: "<center> REACH Burkina Faso - MSNA 2020 - Suivi </center>"
output: html_document

---

Normalment on utilise une combination de ‘blocs de code’ pour evaluer ensemble avec des paragraphes de explication. Ce document de formation a ete cree avec R Markdown.

Le syntaxe de un bloc de code c’est le suivant:

# ``` {r }
# Code
#  ```

Les arguments pour evaluer les blocs de code sont:

Mettez ces arguments dans les accolades au debut du bloc.

# ``` {r echo =F, eval =T, warning =F}
# Code
#  ```

Exercise

  1. Creez un document de markdown dans le meme projet. Definez un document HTML au debut. Importez les donnees et le package dplyr dans un bloc de code.

Group by et summarize dans Markdown

Dans REACH c’est bien comun utiliser les rapports Markdown pour surveiller le progrès des évaluations de besoins. Normalment utilisent des tableaux et graphiques crees avec packages et en utilisant des fonctions de dplyr comme group by et summarize.

hsm_df <- read.csv("donnees/tableaux/REG1903b_3_Frontiers_HSM_Burkina_Faso_2021-03-16.csv", 
                   na.strings = c("NA", "", "N/A", "N.A.", "NnA"),
                   encoding = "UTF-8")

# groupez par admin
enquetes_hsm_admin1 <- hsm_df %>% 
  group_by(admin1) %>% 
  summarise(n_enquetes = n())

Tableaux avec Formattable

Avec formattable on peut creer des tableaux élégants. On passe comme les donnees comme un argument de la fonction formattable.

library(formattable)
# groupez par admin
enquetes_hsm_admin1 <- hsm_df %>% 
  group_by(admin1) %>% 
  summarise(n_enquetes = n())
# creez le tableau
formattable(enquetes_hsm_admin1, list(
  n_enquetes = color_tile("lightpink", "lightgreen")))
admin1 n_enquetes
Centre-Nord 545
Est 630
Nord 448
Sahel 344

Pour nous permetir sorter et ordonner le tableau on peut utiliser le fonction “as.datatable” ensemble avec “formattable”.

library(formattable)
# groupez par admin
enquetes_hsm_admin2 <- hsm_df %>% 
  group_by(admin1, admin2) %>% 
  summarise(n_enquetes = n())
# creez le tableau
as.datatable(formattable(enquetes_hsm_admin2, list(
  n_enquetes = color_bar("lightgreen"))))

Exercise

  1. Creez deux tableaux avec les donnees HSM en utilisant group by, summarize et le package formattable.

4. Géospatiale

4. R Géospatiale: sf et leaflet

R pour applications geoespaciales


Liens clés

Geocomputation avec R

R leaflet

Formation complémentaire en français


Installez et importez les packages pour ce module

library(dplyr)
library(sf)
library(leaflet)
library(raster)
library(rmapshaper)
library(spatialEco)

“sf”

Objets sf (simple features)

sf est un package fournissant un système de classes pour les données vectorielles géographiques. Il est récemment devenu le fondement de l’analyse spatiale chez R. - sf peut représenter tous les types de géométrie vectorielle courants: points, lignes, polygones et leurs versions «multi» respectives.

st_read: chargement de données vectorielles dans R (shp, geojson, kml etc).
st_as_sf: casting comme objet sf dans R (csv, excel)

Lisez donnees avec la fonction sf, “st_read”. Comme argument, on define aussi le CRS (4326 est WGS84).

bfa_admin1 <- st_read("donnees/spatiale/bfa_admin1.geojson", crs= 4326)
bfa_admin2 <- st_read("donnees/spatiale/bfa_admin2.geojson")

Exercise

  • Lisez le admin2 et aussi les chemins trunk.

Avant de faire les cartes on va creer quelques variables de couleur REACH pour faciliter la creation de les styles:

# couleurs REACH
reach_rouge         <- "#EE5859"
reach_rose          <- "#f5a6a7"
reach_orange        <- "#F69E61"
reach_gris          <- "#58585A"
reach_lt_gris       <- "#D1D3D4"
reach_palette_rouge <- c('#FEF2F2','#EE5859', '#772B2C')
blanc               <-  "#FFFFFF"

sf plot (Base R)

Nous pouvons utiliser la fonction plot pour afficher des données spatiales avec sf:

plot(bfa_admin1)

On peut voir que le résultat ici rend un nouveau tracé pour chaque attribut. Aucun de ces autres attributs n’a de sens pour tracer de cette manière, car nous voulons simplement tracer la géométrie de la couche.

Comme dans un dataframe, nous pouvons accéder à des attributs individuels avec l’opérateur ‘$’, y compris la géométrie. Avec l’argument “col” on define la couleur. Maintenant on fait ca:

plot(bfa_admin1$geometry, col= reach_lt_gris)

Adjouter couches

Nous transmettons des options supplémentaires pour une fonction spécifique comme arguments. pour ajouter une couche à la carte: utilisez l’argument add = T. couleur (col) et largeur de ligne (lwd) sont 2 autres arguments que nous pouvons ajouter:

# ajouter le couche de chemins
bfa_chemin_trunk <- st_read("donnees/spatiale/Trunk.shp")
plot(bfa_admin1$geometry, col= reach_lt_gris)

plot(bfa_chemin_trunk$geometry, add = T, col= "brown", lwd = 0.5)

Exercise

  • Faisez un plot avec 2 couches

Nous pouvons utiliser des conditions comme ifelse ou case_when pour mettre en évidence une région:

plot(bfa_admin1$geometry, col = ifelse(bfa_admin1$ADM1_FR == "Est", reach_rouge, reach_lt_gris))

Leaflet

Leaflet est la principale bibliothèque JavaScript open source pour les cartes interactives adaptées aux mobiles. A ete adaptee comme une packages R aussi.

Appelez la fonction de leaflet() et assignez-le un nom. Ajoutez un pipe (%>%) pour chaque nouvelle couche.

Les options de propriété de style sont similaires au sty+le Web et peuvent être vues en entrant? addPolygons dans la console.

L’ordre dans lequel les couches sont appelées dans la fonction est l’ordre dans lequel elles apparaissent sur la carte. Par conséquent, le calque appelé dernier apparaîtra en haut.

bfa_leaflet_map <-  leaflet() %>% 
  addPolygons(
              data        = bfa_admin2, # donnees de couche admin1
              color       = reach_gris, # couleur des frontieres
              fillColor   =  reach_lt_gris, # couleur de remplissage
              weight      = 0.3, # largeur des frontieres
              opacity     = 1.0,  # opacite
              fillOpacity = 0.8,
              label       = bfa_admin2$ADM2_FR,
              highlightOptions = highlightOptions(fillColor="white",
                                   color="white",
                                   weight = 1.4,
                                   bringToFront = F)
              ) 

# affichez la carte
bfa_leaflet_map

nous voulons maintenant ajouter des limites et des étiquettes de region. d’abord on fait une conversion de polygon a ligne pour afficher le frontieres de region.

# autre maniere de faire des lignes admin1 c'est avec un dissolve de admin2. il viens du package rmapshaper
bfa_admin1_dissolve <- rmapshaper::ms_dissolve(bfa_admin2, field="ADM1_FR")

# convert gov boundaries to lines to display on map so they do not clash with district interactivity
bfa_admin1_lignes <- st_cast(bfa_admin1_dissolve,"MULTILINESTRING")
bfa_admin1_lignes <- st_cast(bfa_admin1_lignes,"LINESTRING")

Ces frontieres vont avoir plus largeur. Ces deux couches sont ajoutés en séquence avec le pipe (%>%):

bfa_leaflet_map <-  leaflet() %>% 
  addPolygons(
              data        = bfa_admin2, # donnees de couche admin1
              color       = reach_gris, # couleur des frontieres
              fillColor   =  reach_lt_gris, # couleur de remplissage
              weight      = 0.3, # largeur des frontieres
              opacity     = 1.0,  # opacite
              fillOpacity = 0.8,
              label       = bfa_admin2$ADM2_FR,
              highlightOptions = highlightOptions(fillColor="white",
                                   color="white",
                                   weight = 1.4,
                                   bringToFront = F)
              ) %>% 
    addPolylines(
               data    = bfa_admin1_lignes,
               color   = "black",
               weight  = 0.8,
               opacity = 0.8) 

# affichez la carte
bfa_leaflet_map

Étiquetage avec leaflet

créer des centroids de polygones pour les regions avec la fonction sf “st_centroid” afin de créer des étiquettes:

# prends le controid de couche de admin1
bfa_admin1_centroid <- st_centroid(bfa_admin1)

# vérifier que le type de géométrie est un point
st_geometry_type(bfa_admin1_centroid, by_geometry = F)
## [1] POINT
## 18 Levels: GEOMETRY POINT LINESTRING POLYGON MULTIPOINT ... TRIANGLE

Plot une nouvelle carte avec des étiquettes de région à l’aide de ‘addLabelOnlyMarkers’.

bfa_leaflet_map <-  leaflet() %>% 
  addPolygons(
              data        = bfa_admin2, # donnees de couche admin1
              color       = reach_gris, # couleur des frontieres
              fillColor   =  reach_lt_gris, # couleur de remplissage
              weight      = 0.3, # largeur des frontieres
              opacity     = 1.0,  # opacite
              fillOpacity = 0.8,
              label       = bfa_admin2$ADM2_FR,
              highlightOptions = highlightOptions(fillColor="white",
                                   color="white",
                                   weight = 1.4,
                                   bringToFront = F)
              ) %>% 
    addPolylines(
               data    = bfa_admin1_lignes,
               color   = "black",
               weight  = 0.8,
               opacity = 0.8) %>% 
    addLabelOnlyMarkers(
               data  = bfa_admin1_centroid,
               label = bfa_admin1_centroid$ADM1_FR, # c'est l'atribut utilisee pour creer des etiquetes
               labelOptions = labelOptions(noHide = T,
                            direction = 'center',
                            textOnly = T)) 

# affichez la carte
bfa_leaflet_map

Exercise

  • Avec cette carte au dessus faire une déclaration de ifelse pour souligner une region avec une autre couleur.

Donnees points avec sf

Lisez les donnees SETTLEMENTS_3F_BFA_20200505.xlsx. Pour convertir a un objet spatial on utilise la fonction sf “st_as_sf”:

bfa_villages <- readxl::read_xlsx("donnees/tableaux/SETTLEMENTS_3F_BFA_20200505.xlsx", sheet = "SETTLEMENTS_3F")

Inspectez les donnees des villages pour voire les champs des latitude et longitude.

# convert to sf object and define coordinate columns in order to plot in leaflet
bfa_villages <- bfa_villages %>%
  st_as_sf(
    coords = c("POINT_X", "POINT_Y"), # choose lat and long columns in table 
    crs = 4326)

region_a_filtrer <- "Sahel"

bfa_admin1_filtree <- bfa_admin1 %>% 
  filter(ADM1_FR == region_a_filtrer)

villages_filtree <-  st_intersection(bfa_villages, bfa_admin1_filtree)

Ajoutez les points a la carte leaflet avec la fonction “addCircleMarkers”

bfa_leaflet_map <-  leaflet() %>% 
  addPolygons(
              data        = bfa_admin2, # donnees de couche admin1
              color       = reach_gris, # couleur des frontieres
              fillColor   =  reach_lt_gris, # couleur de remplissage
              weight      = 0.3, # largeur des frontieres
              opacity     = 1.0,  # opacite
              fillOpacity = 0.8,
              label       = bfa_admin2$ADM2_FR,
              highlightOptions = highlightOptions(fillColor="white",
                                   color="white",
                                   weight = 1.4,
                                   bringToFront = F)
              ) %>% 
    addPolylines(
               data    = bfa_admin1_lignes,
               color   = "black",
               weight  = 0.8,
               opacity = 0.8) %>% 
    # ajoutez points a la carte
  addCircleMarkers( 
               data = villages_filtree, 
               color = reach_orange,
               fillColor = reach_orange,
               radius=1,
               weight=0.2,
               fillOpacity = 0.8,
               popup = bfa_villages$NomLocalit) %>% 
    addLabelOnlyMarkers(
               data  = bfa_admin1_centroid,
               label = bfa_admin1_centroid$ADM1_FR, # c'est l'atribut utilisee pour creer des etiquetes
               labelOptions = labelOptions(noHide = T,
                            direction = 'center',
                            textOnly = T)) 

# affichez la carte
bfa_leaflet_map

zonal statistics et cartes choropleths

Telechargez les donnees de population BF de facebook

Importez les donnees avec le package raster

pop_bfa_2018 <- raster::raster("donnees/spatiale/population_bfa_2018-10-01.tif")

Maintenant on peut calculer la population des provinces de Burkina et afficher sure une carte leaflet. Pour calculer les statistiques zonales on va utiliser le package “spatialEco”.

pop_2018 <- spatialEco::zonal.stats(bfa_admin2, pop_bfa_2018, stats = "sum")

# faire un bind pour mettre les statistiques dans les donnees admin2
bfa_admin2 <- cbind(bfa_admin2, pop_2018) %>% 
  dplyr::rename(pop_2018 = sum.population_bfa_2018.10.01)

Finalment on fait la carte de population et define l’etiquette comme un palette REACH.

pal_population <- colorNumeric(
  palette = colorRampPalette(reach_palette_rouge)(length(bfa_admin2$pop_2018)), 
  domain = bfa_admin2$pop_2018, na.color = reach_lt_gris)

carte_bfa_leaflet_choropleth <-  leaflet() %>% 
  addPolygons(
    data        = bfa_admin2, # donnees de couche admin1
    color       = reach_gris, # couleur des frontieres
    fillColor   =  ~pal_population(pop_2018),  # couleur de remplissage
    weight      = 0.3, # largeur des frontieres
    opacity     = 1.0,  # opacite
    fillOpacity = 0.8,
    label       = paste0(bfa_admin2$ADM2_FR, "- Population: ", formatC(bfa_admin2$pop_2018,format="f", big.mark=",", digits=0)), 
    highlightOptions = highlightOptions(fillColor = reach_gris,
                                        color     = reach_gris,
                                        weight    = 1.4,
                                        bringToFront = F)
  ) %>% 
  addPolylines(
    data    = bfa_admin1_lignes,
    color   = "black",
    weight  = 0.8,
    opacity = 0.8) %>% 
  addLabelOnlyMarkers(
    data  = bfa_admin1_centroid,
    label = bfa_admin1_centroid$ADM1_FR, # c'est l'atribut utilisee pour creer des etiquetes
    labelOptions = labelOptions(noHide    = T,
                                direction = 'center',
                                textOnly  = T,
                                style     = list(
                                  "padding"     = "3px 8px",
                                  "font-family" = "Arial",
                                  "text-shadow" = sprintf("-1px 0 %s, 0 1px %s, 1px 0 %s, 0 -1px %s, 0 0 7px %s", blanc, blanc, blanc, blanc, blanc)
                                )) 
  )%>% 
  
  # ajoutez legende gradient
  leaflet::addLegend(position  = "bottomright",
                     pal       = pal_population,
                     values    = bfa_admin2$pop_2018,
                     title   = "Population",
                     bins    = 5,
                     opacity = 1) %>%
  # ajoutez echelle
  addScaleBar(position = "bottomleft", 
              scaleBarOptions(imperial = FALSE))

# affichez la carte
carte_bfa_leaflet_choropleth

5. Graphiques

5. Graphiques avec R


Packages des graphiques

Installez et importez les packages pour ce module

library(dplyr)
library(ggplot2)
library(plotly)
library(highcharter)

Durant cet exercise on va utiliser Base R et les packages ggplot2, plotly et highcharter.

ggplot2

ggplot2 est un système de création déclarative de graphiques. Normalment on utilise la fonction ggplot2() avec une declaration pour les donnees, pour la cartographie esthétique (aes()) et apres on define le type de graphique.

Highcharter et Plotly

Ces deux packages facilitent la construction de graphiques de manière plus interactive.

Importez les donnees HSM autre fois

hsm_df <- read.csv("donnees/tableaux/REG1903b_3_Frontiers_HSM_Burkina_Faso_2021-03-16.csv", 
                   na.strings = c("NA", "", "N/A", "N.A.", "NnA"),
                   encoding = "UTF-8")

Histogram

Regroupe les nombres en plages. Graphique le plus couramment utilisé pour montrer les distributions de fréquences.

Avec Base R – hist() :

# age des personnes IC dans la region de l'Est. Les bins defaut sont de 5.
hist(hsm_df$ic_age[hsm_df$admin1 == "Est"], main = "Age des IC en region Est")

Avec ggplot2 – geom_histogram() :

# age des personnes IC dans la region de l'Est. Les bins sont de 5.
ggplot(hsm_df, aes(x=ic_age)) + 
  geom_histogram()
## `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.

Et Highcharter:

# age des personnes IC dans la region de l'Est. Les bins sont de 5.
hchart(hsm_df$profession_ic[hsm_df$admin1 == "Est"], name = "IC Age - Region Est") 

Graphique Barres

Les graphiques à barres sont utilisés pour comparer des éléments entre différents groupes ou pour suivre les changements au fil du temps.

Avec Base R – fonction barplot() :

# faire le group by et summarize avec la region

hsm_ic_age_admin1 <- hsm_df %>% 
  group_by(admin1) %>% 
  summarize(moy_ic_age = mean(ic_age))
## `summarise()` ungrouping output (override with `.groups` argument)
barplot(height=hsm_ic_age_admin1$moy_ic_age, names=hsm_ic_age_admin1$admin1, 
        col=rgb(0.8,0.1,0.1,0.6),
        xlab="Region", 
        ylab="Age", 
        main="Moyenne age par region", 
        ylim=c(0,60)
        )

Avec ggplot2 – geom_bar() :

ggplot(hsm_ic_age_admin1, aes(x=admin1, y=moy_ic_age)) + 
  geom_bar(stat = "identity")

Horizontal avec ggplot2 - ajoutez coord_flip() :

ggplot(hsm_ic_age_admin1, aes(x=admin1, y=moy_ic_age)) + 
  geom_bar(stat = "identity") +
  coord_flip()

#### Graphique barres empilées

Avec Plotly – plot_ly() + layout() :

Graphique Line

les graphiques en courbes peuvent être utilisés pour montrer un changement au fil du temps.

Avec ggplot2 – geom_line() :

# faire le group by et summarize avec la date
hsm_df_date <- hsm_df %>% 
  group_by(today, statut_deplacement) %>% 
  summarize(n = n())
## `summarise()` regrouping output by 'today' (override with `.groups` argument)
ggplot(hsm_df_date, aes(x=today, y=n, group=statut_deplacement, color=statut_deplacement)) +
    geom_line()+
    theme(legend.position="bottom")

Avec highcharter:

Diagramme Donut

Avec Plotly – plot_ly() + layout() :

6. Analyse

Introduction

Cette formation se concentre sur la façon d’analyser les données d’enquête dans R. Elle vous apprendra étape par étape comment obtenir les moyennes et les proportions de la population à partir de vos ensembles de données quantitatives, pour les échantillons non pondérés et pondérés (regroupés / stratifiés).

Il ne s’agit pas d’une formation sur le package hypegrammaR de HQ, mais utilise plutôt les célèbres packages R survey et srvyr. srvyr est construit sur l’enquête bien documentée, mais a l’avantage supplémentaire d’utiliser une syntaxe qui peut facilement être combinée avec le paquet de travail dplyr et toutes ses fonctions. De plus, srvyr renvoie les résultats dans un format standardisé, qui peut être plus facile à utiliser qu’une enquête.

Au debut on define deux objets - les donnees comme toujours et cadre d’échantillonnage qui a seulement 2 colonnes, le nom de strata et le numero de population. Normalment le format de colonne "strata’ est comme ca - unite_de_couverture + groupe_de_population (ie. est_communaute_hote ou sanmatenga_pdi)

Au debut, on va importer les donnees nettoyees de MSNA et filtrer pour population locale cette fois:

data <- read.csv("input/donnees/bfa2002_msna_jour35_nettoyage_2020.csv", na.strings = c("NA", "", "N/A"), stringsAsFactors = F) %>% 
  filter(group_pop == "pop_local")

Et apres le cadre d’echantillonage (sampling frame). Mais c’est necessaire proceder un peu. On veut faire un analisis au niveau de admin1.

sampling_frame <- read.csv("input/echantillon/REACH_BFA_Pop_for_weighting_20201308.csv", na.strings = c("NA", "", "N/A"), fileEncoding="UTF-8-BOM") %>% 
  group_by(admin1) %>% 
  summarize(population = sum(Total.local)) %>% 
  mutate(admin1 = paste0(gsub(" |-", "_", tolower(admin1)), "_pop_local")) %>% 
  rename(strata = admin1)

Maintenant on va creer une variable de strata dans les donnees pour faire un join avec le sampling frame.

data$strata <- paste0(data$admin1, "_", data$group_pop) 

Joigner sampling frame et donnees

data <- left_join(data, sampling_frame, by = "strata") 

Analyse avec Survey

Objet svydesign

Ici on conçoit un objet “design_survey” avec la fonction “svydesign”.

L’argument id définit les ID des clusters (du plus grand au plus petit). Dans le cas de l’échantillonnage stratifié uniquement, laissez l’argument vide en spécifiant ~ 1. Définissez l’argument strata comme la colonne que vous avez spécifiée ci-dessus avec les noms de strates (précédés de ~). fpc signifie «population finie correcte» et spécifie la colonne dans laquelle vous avez vos estimations de population. À l’aide de ces estimations, l’enquête calculera des statistiques pondérées.

design_survey <- svydesign(data = data, id =~1, strata = ~strata, fpc = ~population)

Survey - Analyse sans désagrégation

Avec l’objet design maintenant on peut analyser.

Pour les variables numériques et catégorielles, vous appelez la fonction svymean (). Appelez l’indicateur que vous souhaitez analyser (précédé de ~), ainsi que l’objet de conception de l’enquête. Ajoutez na.rm = TRUE si vous souhaitez exclure toutes les valeurs vides (NA). SE c’est l’erreur standarde.

Un example avec un variable numerique:

svymean(~ic_age, design_survey, na.rm = TRUE)
##          mean     SE
## ic_age 42.915 0.3331

Et avec une variable catégorique:

svymean(~situation_matrimoniale, design_survey, na.rm = TRUE)
##                                          mean     SE
## situation_matrimonialecelibataire    0.018076 0.0033
## situation_matrimonialedivorce        0.005398 0.0017
## situation_matrimonialeencouple       0.067811 0.0054
## situation_matrimonialemarie_monogame 0.567142 0.0107
## situation_matrimonialemarie_polygame 0.272775 0.0090
## situation_matrimonialemarie_veuf     0.068798 0.0062

Survey - Analyse avec désagrégation

Pour analyser avec une désagrégation on appelle la fonction “svyby”. C’est comme le suivant ou on define le niveau de désagrégation avec la deuxieme argument:

svyby(~taille_abri, ~admin1, design_survey, svymean, na.rm=T)
##                              admin1 taille_abri        se
## boucle_du_mouhoun boucle_du_mouhoun    43.58971  1.329364
## cascades                   cascades    38.85106  2.685893
## centre                       centre    49.54237  2.949482
## centre_est               centre_est    51.69672  3.711088
## centre_nord             centre_nord    44.02723  1.349356
## centre_ouest           centre_ouest    64.78030  9.684927
## centre_sud               centre_sud    40.01550  3.081962
## est                             est    88.40262  5.918747
## hauts_bassins         hauts_bassins    40.54545  3.426680
## nord                           nord    59.33714  2.046345
## plateau_central     plateau_central    49.01587  3.677650
## sahel                         sahel   178.86378 44.846138
## sud_ouest                 sud_ouest    36.02500  2.148416

Analyse avec srvyr

Le package ‘srvyr’ s’appuie sur survey, ajoutant la capacité d’utiliser les fonctions dyplyr. #### Objet svydesign

Avec le package srvyr on define l’objet de survey design comme ca:

design_srvyr <- data %>% 
  as_survey_design(ids = 1, strata = strata, fpc = population)

Valeurs numeriques - sans désagrégation

Ici on va utiliser les fonctions de dplyr ensemble avec survey_mean:

design_srvyr %>%
  summarise(mean = survey_mean(ic_age, na.rm = TRUE))
## # A tibble: 1 x 2
##    mean mean_se
##   <dbl>   <dbl>
## 1  42.9   0.333

Valeurs numeriques - avec désagrégation

Ici on va utiliser le group_by de dplyr ensemble avec survey_mean:

design_srvyr %>%
  group_by(admin1) %>%
  summarise(mean = survey_mean(taille_abri, na.rm = TRUE, vartype = "ci"))
## # A tibble: 13 x 4
##    admin1             mean mean_low mean_upp
##    <chr>             <dbl>    <dbl>    <dbl>
##  1 boucle_du_mouhoun  43.6     41.0     46.2
##  2 cascades           38.9     33.6     44.1
##  3 centre             49.5     43.8     55.3
##  4 centre_est         51.7     44.4     59.0
##  5 centre_nord        44.0     41.4     46.7
##  6 centre_ouest       64.8     45.8     83.8
##  7 centre_sud         40.0     34.0     46.1
##  8 est                88.4     76.8    100. 
##  9 hauts_bassins      40.5     33.8     47.3
## 10 nord               59.3     55.3     63.3
## 11 plateau_central    49.0     41.8     56.2
## 12 sahel             179.      90.9    267. 
## 13 sud_ouest          36.0     31.8     40.2

Notez que dans la sortie des résultats, il y a maintenant 4 colonnes: 1) désagrégations, 2) moyenne, 3) borne inférieure de l’intervalle de confiance et 4) borne supérieure de l’intervalle de confiance (niveau de confiance de 0,95 par défaut).

Les intervalles de confiance (IC) peuvent être utiles pour déterminer rapidement si les différences entre les groupes sont statistiquement significatives. Si les IC ne se chevauchent pas, la différence est statistiquement significative. Si les CI se chevauchent, vous devrez peut-être exécuter un test de signification pour le savoir.


Valeurs catégorielles - sans désagrégation

Ici encore on utilise le group by:

design_srvyr %>%
  group_by(genre_chef_menage) %>%
  summarise(mean = survey_mean(vartype = "ci"))
## # A tibble: 3 x 4
##   genre_chef_menage   mean mean_low mean_upp
##   <chr>              <dbl>    <dbl>    <dbl>
## 1 femme             0.0180   0.0112   0.0249
## 2 homme             0.295    0.275    0.315 
## 3 <NA>              0.687    0.667    0.708

Valeurs catégorielles - avec désagrégation

Ici encore on utilise le group by mais avec tous les variables (la variable de désagrégation primiere). On utilise filtrer

design_srvyr %>%
  group_by(admin1, ic_genre) %>%
  summarise(mean  = survey_mean(vartype = "ci"))
## # A tibble: 26 x 5
## # Groups:   admin1 [13]
##    admin1            ic_genre  mean mean_low mean_upp
##    <chr>             <chr>    <dbl>    <dbl>    <dbl>
##  1 boucle_du_mouhoun femme    0.36     0.328    0.392
##  2 boucle_du_mouhoun homme    0.64     0.608    0.672
##  3 cascades          femme    0.319    0.224    0.414
##  4 cascades          homme    0.681    0.586    0.776
##  5 centre            femme    0.492    0.401    0.582
##  6 centre            homme    0.508    0.418    0.599
##  7 centre_est        femme    0.443    0.354    0.531
##  8 centre_est        homme    0.557    0.469    0.646
##  9 centre_nord       femme    0.297    0.252    0.342
## 10 centre_nord       homme    0.703    0.658    0.748
## # ... with 16 more rows

Adjouter un nombre

Valeurs numeriques. Adjouter un mutate avec le nom “count”:

design_srvyr %>%
  group_by(admin1) %>% 
  summarise(mean  = survey_mean(ic_age, na.rm = TRUE, vartype = "ci"),
            count = unweighted(sum(!is.na(ic_age))))
## # A tibble: 13 x 5
##    admin1             mean mean_low mean_upp count
##    <chr>             <dbl>    <dbl>    <dbl> <int>
##  1 boucle_du_mouhoun  41.8     40.8     42.7   875
##  2 cascades           44.9     42.0     47.9    94
##  3 centre             39.2     36.7     41.6   118
##  4 centre_est         44.0     41.2     46.7   122
##  5 centre_nord        45.0     43.5     46.4   404
##  6 centre_ouest       47.9     45.2     50.7   132
##  7 centre_sud         45.7     43.2     48.2   129
##  8 est                39.5     38.6     40.5   691
##  9 hauts_bassins      40.1     37.0     43.3   110
## 10 nord               47.3     45.9     48.6   525
## 11 plateau_central    44.9     41.9     47.9   126
## 12 sahel              43.4     42.3     44.4   632
## 13 sud_ouest          39.6     37.1     42.0   120

Et valeurs catégorielles

design_srvyr %>%
  group_by(admin1, ic_genre) %>%
  summarise(mean  = survey_mean(vartype = "ci"),
            count = unweighted(n()))
## # A tibble: 26 x 6
## # Groups:   admin1 [13]
##    admin1            ic_genre  mean mean_low mean_upp count
##    <chr>             <chr>    <dbl>    <dbl>    <dbl> <int>
##  1 boucle_du_mouhoun femme    0.36     0.328    0.392   315
##  2 boucle_du_mouhoun homme    0.64     0.608    0.672   560
##  3 cascades          femme    0.319    0.224    0.414    30
##  4 cascades          homme    0.681    0.586    0.776    64
##  5 centre            femme    0.492    0.401    0.582    58
##  6 centre            homme    0.508    0.418    0.599    60
##  7 centre_est        femme    0.443    0.354    0.531    54
##  8 centre_est        homme    0.557    0.469    0.646    68
##  9 centre_nord       femme    0.297    0.252    0.342   120
## 10 centre_nord       homme    0.703    0.658    0.748   284
## # ... with 16 more rows

Analyse avec HypegrammaR

Le package hypegrammaR a été créé par IMPACT HQ pour soutenir l’analyse quantitative en R. Il met en œuvre les directives d’analyse quantitative des données IMPACT
Il est fortement recommandé d’inclure des dossiers séparés «input» et «output» dans votre projet de HypegrammaR. Le dossier «input» contient le questionnaire, la base de sondage, les données nettoyées, le plan d’analyse. Le dossier «output» contient les résultats de l’analyse.

Installez et chargez Hypegrammar

library(devtools)
devtools::install_github("https://github.com/impact-initiatives/hypegrammaR")
library(hypegrammaR)

Le dossier «input»

Données d’évaluation nettoyées * Il est essentiel que les noms de colonne de l’ensemble de données utilisent les noms kobo (XML values as headers). * Si vous avez ajouté de nouvelles variables recodées dans votre ensemble de données, il est recommandé de les ajouter en tant que lignes supplémentaires au questionnaire, en spécifiant le type de variable, les choix, etc. * Assurez-vous que les informations personnellement identifiées et les données sensibles sont supprimées de l’ensemble de données nettoyé.

Pour cet exercise on va utiliser les donnees de MSNA comme ci-dessus, et faire cette analyse avec **seulement le groupe de populaion locale.

Cadre d’échantillonnage – qui a seulement 2 colonnes, le nom de strata et le numero de population.

  • Normalment le format de colonne "strata’ est comme ca - unite_de_couverture + groupe_de_population (ie. est_communaute_hote ou sanmatenga_pdi). Ici on n’a pas des statistiques pour les autres population donc on va incluye seulement le population local aussi.

Outil Maintenant on importe les questions et les choix de l’outil:

questions       <- readxl::read_excel("input/outil/bfa_msna_outil_V2.xlsx", sheet="survey")
choices      <- readxl::read_excel("input/outil/bfa_msna_outil_V2.xlsx", sheet="choices")

plan d’analyse des données (DAP) The data analysis plan should have nine columns, as outlined in the file below:

dap    <- read.csv("input/dap/dap_msna2020.csv")
head(dap)
##   ï..Indicator.Group...Sector research.question sub.research.question
## 1                          NA                NA                    NA
## 2                          NA                NA                    NA
## 3                          NA                NA                    NA
## 4                          NA                NA                    NA
## 5                          NA                NA                    NA
## 6                          NA                NA                    NA
##   repeat.for.variable independent.variable independent.variable.type
## 1              admin1            group_pop               categorical
## 2              admin1            group_pop               categorical
## 3              admin1            group_pop               categorical
## 4              admin1            group_pop               categorical
## 5              admin1            group_pop               categorical
## 6              admin1            group_pop               categorical
##       dependent.variable dependent.variable.type  hypothesis.type hypothesis
## 1               modalite             categorical direct_reporting         NA
## 2         sexe_enqueteur             categorical direct_reporting         NA
## 3               ic_genre             categorical direct_reporting         NA
## 4            chef_menage             categorical direct_reporting         NA
## 5      genre_chef_menage             categorical direct_reporting         NA
## 6 situation_matrimoniale             categorical direct_reporting         NA

Chargez les fichiers

assessment_data <- load_data(file = "input/donnees/bfa2002_msna_jour35_nettoyage_2020.csv") %>% 
    filter(group_pop == "pop_local" | group_pop == "pdi")
sampling_frame_final  <- load_samplingframe(file ="input/echantillon/sampling_frame_clean.csv")
questionnaire   <- load_questionnaire(data = assessment_data,
                                      questions = questions,
                                      choices = choices,
                                      choices.label.column.to.use = "label"
                                      )
analysisplan    <- load_analysisplan("input/dap/dap_msna2020.csv")

Ensuite, definez la variable de stratification entre les donnees et le cadre d’echantillonage. Parallèle q’on a fait avec le preparation en utilisant le package survey.

Apres creez la variable de strata dans les donnees.

assessment_data$strata <- paste0(assessment_data$admin1, "_", assessment_data$group_pop) 

Maintenant on peut appeler le poids avec la fonction “map_to_weighting”

Ici c’est important specifier le colonne specifique pour joigner les donnes avec l’echantillon.

weights <- map_to_weighting(sampling.frame = sampling_frame_final,
                            data.stratum.column = "strata", # la colonne strata pour joigner cote des donnees
                            sampling.frame.population.column = "population", # colonne avec population dans l'echantillon
                            sampling.frame.stratum.column = "strata"  # la colonne strata pour joigner cote d'echantillon
                            )

Calculs non pondérés: si votre évaluation n’est pas stratifiée / pondérée, il n’est pas nécessaire de charger une base de sondage à l’étape 2. Vous devrez également supprimer les étapes 3 et 4, et supprimer la ligne «pondération» à l’étape 5.

Lancer l’analyse

results <- from_analysisplan_map_to_output(assessment_data, 
                                          analysisplan = analysisplan,
                                          weighting = weights,
                                          questionnaire = questionnaire, 
                                          confidence_level = 0.9)

Exportez les résultats

map_to_master_table()

results_output <- map_to_master_table(results$results, "output/analysis_results.csv")
head(results_output)
##   dependent.var independent.var independent.var.value dependent.var.value
## 1      modalite       group_pop                   pdi              direct
## 2      modalite       group_pop             pop_local              direct
## 3      modalite       group_pop                   pdi              direct
## 4      modalite       group_pop                   pdi           telephone
## 5      modalite       group_pop             pop_local              direct
## 6      modalite       group_pop             pop_local           telephone
##     numbers se       min       max repeat.var repeat.var.value
## 1 1.0000000 NA        NA        NA     admin1       centre_est
## 2 1.0000000 NA        NA        NA     admin1       centre_est
## 3 0.4936709 NA 0.4558498 0.5314920     admin1            sahel
## 4 0.5063291 NA 0.4685080 0.5441502     admin1            sahel
## 5 0.5696203 NA 0.5371827 0.6020578     admin1            sahel
## 6 0.4303797 NA 0.3979422 0.4628173     admin1            sahel

7. Shiny

7. Introduction a Applications Shiny


Shiny

Shiny est un package R qui facilite la création d’applications Web interactives directement avec R.


Applications Shiny contiennent un script qui s’appele app.R, dans un projet R. Dans le script de app.R il y a trois composants:

  • Un objet de ui (interface utilisateur) qui contrôle la disposition et l’apparence

  • Une fonction de server

  • Un appel a la fonction de shinyApp, qui crée des objets d’application Shiny à partir d’une paire défini.


Installez et chargez le package de shiny:

install.packages("shiny")
library(shiny)

Une description simplifiée du contenu d’une application Shiny:

ui <- ...

server <- ...

shinyApp(ui, server)

Maintenant on va creer un application basique. C’est le plus courant utiliser la fonction fluidPage pour creer le UI. Pour le moment on va laisser vide le server. titlePanel et sidebarLayout sont les deux éléments les plus populaires à ajouter à fluidPage. Ils créent une application Shiny de base avec une barre latérale.

# Definez UI ----
ui <- fluidPage(
  titlePanel("panneau de titre"),
  sidebarLayout(
    sidebarPanel("panneau sidebar"),
    mainPanel("panneau principal")
  )
)
# Definez logique du serveur ----
server <- function(input, output) {
}
# Lancez la app
shinyApp(ui, server)
runApp("ma_app") # avec le nom de l'application

Contenu HTML

On ajoute texte de HTML comme fonctions appelé avec les memes noms des tags HTML:

# Definez UI ----
ui <- fluidPage(
  titlePanel("Application Shiny"),
  sidebarLayout(
    sidebarPanel( img(src = "www/reach_logo.png", height = 100, width = 200),
                  h3("Ici le panneau sidebar. C'est gris parce qu'on a adjouté l'argument 'style = color:grey' ", style = "color:grey")),
    mainPanel(
      p("p() crée un paragraphe de texte."),
      strong("strong() rend le texte en gras."),
      em("em() crée du texte en italique."),
      br(),
      p("span fait la même chose que div, mais il fonctionne avec",
        span("groupes de mots", style = "color:red"),
        "qui apparaissent à l'intérieur d'un paragraphe.")
    )
  )
)
# Definez logique du serveur ----
server <- function(input, output) {
}
# Lancez la app
shinyApp(ui, server)

Resultats:

Exercise

  • creez un petite UI Shiny de la même manière que ci-dessus et peuplez les panneaux sidebar et main avec texte des plusieurs formes HTML.

Contrôle des widgets

Les widgets sont des éléments Web avec lesquels vos utilisateurs peuvent interagir. Les widgets permettent à vos utilisateurs d’envoyer des messages à l’application Shiny.

Types des widgets:

Pour apprendre plus visitez le Shiny Wudgets Gallery


Ajouter des widgets

Nous ajoutons des widgets de la même manière que nous avons ajouté d’autres types de contenu HTML, dans l’objet de UI. Chaque fonction de widget nécessite plusieurs arguments. Les deux premiers arguments de chaque widget sont:

  • un nom pour le widget: l’utilisateur ne verra pas ce nom, mais vous pouvez l’utiliser pour accéder à la valeur du widget. Le nom doit être une chaîne de caractères.

  • une étiquette: cette étiquette apparaîtra avec le widget dans votre application. Il doit s’agir d’une chaîne de caractères, mais il peut s’agir d’une chaîne vide "".

Les arguments restants varient d’un widget à l’autre, en fonction de ce dont le widget a besoin pour faire son travail. Ils incluent des éléments tels que les valeurs initiales, les plages et les incréments. Vous pouvez trouver les arguments exacts nécessaires à un widget sur la page d’aide de la fonction de widget, comme ?SelectInput.

Voici des exemples des types de widgets arrangés comme fluidRow dans un fluidPage. indique que va adapter a le largeur du navigateur. Dans chaque fluidRow on define des colonnes - le premier argument est la largeur de la colonne.

# Definez UI ----
ui <- fluidPage(
  titlePanel("Application Shiny"),
  fluidRow(
    column(6, 
           sliderInput("slider1", h3("input curseur"),
                       min = 0, max = 100, value = 50),
           sliderInput("slider2", "",
                       min = 0, max = 100, value = c(25, 75))
    ),
    column(3,
           h3("Case à cocher unique"),
           checkboxInput("checkbox", "Choix A", value = TRUE)),
  
  ),
  fluidRow(
    column(6, 
           checkboxGroupInput("checkGroup", 
                              h3("Case à cocher multiple"), 
                              choices = list("choix 1" = 1, 
                                             "choix 2" = 2, 
                                             "choix 3" = 3),
                              selected = 1)),
    column(3,
           fileInput("file", h3("Télécharger un fichier"))),
  ),
  fluidRow(
    column(6,
           radioButtons("radio", h3("Boutons radio"),
                        choices = list("Choice 1" = 1, "Choice 2" = 2,
                                       "Choice 3" = 3),selected = 1)),
    column(3,
           selectInput("select", h3("menu déroulant"), 
                       choices = list("choix 1" = 1, 
                                      "choix 2" = 2,
                                      "choix 3" = 3), 
                       selected = 1)),
  )
)
# Definez logique du serveur ----
server <- function(input, output) {
}
# Lancez la app
shinyApp(ui, server)

Afficher les outputs réactives

Regles pour outputs réactives

  • utilisez une fonction Output dans l’interface utilisateur pour placer des objets réactifs dans votre application Shiny.
  • utilisez une fonction render sur le serveur pour indiquer à Shiny comment construire vos objets.
  • entourer les expressions R par des accolades, {}, dans chaque fonction render.
  • enregistrez vos expressions de “render” dans la liste de sortie, avec une entrée pour chaque objet réactif de votre application.
  • créer de la réactivité en incluant une valeur d’entrée dans une expression de “render”.

Types des outputs:


Example de un output réactive

ui <- fluidPage(
  titlePanel("Groupe de population"),
  
  sidebarLayout(
    sidebarPanel(
      helpText("Create Population group data"),
      
      selectInput("var", 
                  label = "Choisissez un groupe de population",
                  choices = c("PDI", 
                              "Communauté hôte", 
                              "Refugie"),
                  selected = "Communauté hôte"),
      
      sliderInput("range", 
                  label = "Gamme d'intérêt:",
                  min = 0, max = 100, value = c(0, 100))
    ),
    
    mainPanel(
      textOutput("selected_var"),
      textOutput("min_max")
    )
  )
)

server <- function(input, output) {
  
  output$selected_var <- renderText({ 
    paste("Vous avez sélectionné", input$var)
  })
  
  output$min_max <- renderText({ 
    paste("Vous avez choisi une gamme allant de",
          input$range[1], "à", input$range[2])
  })
  
}

shinyApp(ui, server)

Resultats:


library(shiny)
library(plotly)
library(dplyr)
library(ggplot2)

# global - manipulation des donnees
# lisez les donnees HSM
data <- read.csv("donnees/tableaux/REG1903b_3_Frontiers_HSM_Burkina_Faso_2021-03-16.csv",
                 stringsAsFactors = F,
                 na.strings = c("NA", "N/A",""),
                 encoding="UTF-8")

data$type_evaluation_cort <- case_when(data$type_evaluation == "J'évalue la localité à distance avec un informateur-clé EN PERSONNE" ~ "distance_personne",
                                  data$type_evaluation == "J'évalue la localité à distance avec un informateur-clé PAR TÉLÉPHONE" ~ "dist_telephone",
                                  data$type_evaluation == "Visites terrains - Je suis dans la localité évaluée avec l'informateur-clé" ~ "ic")

# objet UI
ui <- bootstrapPage(
        navbarPage("Exercise navbar page",
                 tabPanel("tab 1 - type_enquete",
                          sidebarLayout(
                            sidebarPanel(
                                    selectInput("region",
                                                "selectionnez base:",
                                                choices = sort(unique(data$base)))
                            ),
                            mainPanel(
                              plotOutput(outputId = "graphique_stacked", height = "400px", width = "450px"),
                            )
                          )),
                 tabPanel("tab 2 - nourriture maintenant",
                          sidebarLayout(
                            sidebarPanel(
                              selectInput("region2",
                                          "selectionnez base:",
                                          choices = sort(unique(data$base)))
                            ),
                            mainPanel(
                              plotOutput(outputId = "graphique_stacked2", height = "400px", width = "450px"),
                            )
                          ))
)
)
# fonction de server 
server <- function(input, output, session) {
  
  output$graphique_stacked <- renderPlot({
    
    region <- input$region
    
    data_filtree <- data %>% 
      filter(base == region)
    
    ggplot(data_filtree) + 
      geom_bar(aes(x = global_enum_id, fill = type_evaluation_cort))+ 
      theme(axis.text.x = element_text(angle = 90, vjust = 0.5, hjust=1))
  })
  
  output$graphique_stacked2 <- renderPlot({
    
    region2 <- input$region2
    
    data_filtree2 <- data %>% 
      filter(base == region2)
    
    ggplot(data_filtree2) +
      geom_bar(aes(x = admin2, fill = nourriture_maintenant))+
      theme(axis.text.x = element_text(angle = 90, vjust = 0.5, hjust=1))
  })
}

# lancer l'application
shinyApp(ui, server)

Resultats:


Exemples intégrés.

Le package Shiny est livré avec de nombreux exemples que nous pouvons consulter pour nous aider:

runExample("01_hello")      # un histogramme
runExample("02_text")       # tableaux et blocs de données
runExample("03_reactivity") # une expression réactive
runExample("04_mpg")        # variables globales
runExample("05_sliders")    # barres de défilement
runExample("06_tabsets")    # panneaux à onglets
runExample("07_widgets")    # texte d'aide et boutons d'envoi
runExample("08_html")       # Application Shiny construite à partir de HTML
runExample("09_upload")     # assistant de téléchargement de fichiers - upload
runExample("10_download")   # assistant de téléchargement de fichiers - downlaod
runExample("11_timer")      # une minuterie automatisée